1. Field of the Invention
The present invention relates to a system for analyzing and debugging software through dynamic and interactive use of code markers, and more particularly, to a system and method of using code markers to analyze complex host computer and embedded microprocessor based software systems, even those with on-board caches and queues, so as to eliminate most dependencies on particular processors and language systems.
2. Description of the Prior Art
In recent years, software has had increasing importance in the computer industry. Software is used to control many increasingly complex processes, and the software itself has accordingly become increasingly complex. Many tools have been developed for assisting a software engineer in the development of such complex software. Such tools include compilers, assemblers, linkers, editors and the like, as well as other specification and design tools, configuration management tools, language smart editors and the like. Other tools, such as microprocessor emulators, also have been designed for operation on general purpose computers to assist software engineers in the development of software. Such products have led to the developing discipline of Computer Aided Software Engineering (CASE).
One of the primary tasks of the software engineer is to analyze his or her code to determine whether the code operates as desired so that if an error is found, a debugging process may be conducted. Traditional debugging methods include slow manual processes such as inserting print statements into the software at particular locations so that the values of variables and the like may be checked to determine if they have the expected values. However, such an approach is no longer desired because it results in very high overhead and intrusion on the operation of the code being examined. Moreover, such print statements are difficult to use in embedded software systems because the target processor on which the software is to run must have a port for the printed statements to be communicated to the output. As known to those skilled in the art, embedded systems are software/hardware systems dedicated to an application which requires consistent and timely control of, and response to, external events. Embedded systems may also involve presenting information about those events and allowing user interaction with the parameters controlling the application. It is thus desirable to develop a debugging system which can be used to debug software having application specific I/0.
Software and hardware debugging systems have also been designed to assist the software engineer in the debugging process. However, such debuggers are generally restricted to use with particular language systems and, as a result, are static and non-real-time. Moreover, such debuggers are generally not widely available for embedded environments because of the unpredictability of external events to which the system responds. Debuggers have thus been of limited utility for embedded software systems.
In recent years, logic analyzers have also been used by software engineers to aid in debugging their code by providing low level views of microprocessor bus cycles and other logical blocks within the system. However, such logic analyzers require intimate knowledge of the microprocessor on which the software is operating in order to allow the user to view the data. Moreover, the data is generally not visible if the processor has an on board cache and is difficult to extract if the processor uses queueing or pipelining as in graphics systems, for example. Thus, logic analyzers are generally not geared for use by software engineers and, accordingly, are not particularly user friendly to software engineers.
Other debugger technology has been developed to appeal to the abstraction level of high level language software engineers. For example, a product called Validate/XEL.TM. has been provided to software engineers as an interface on top of an emulator which is designed to allow full speed emulation, modular architecture and high-speed downloads. However, such a system does not address the needs of large software design teams and cannot adequately handle rapidly increasing code sizes.
Another debugging tool which has been developed to assist software engineers is the Software Analysis Workbench (SAW). SAW hooks up to an IBM-Compatible PC-AT and ties to language tools in that environment. SAW can capture events in real-time and can monitor real-time execution without intrusion on the underlying software process. However, SAW does not address the problems of caches and prefetched queues and does not eliminate most dependencies on particular processors and language systems. A better debugging tool for embedded systems is desired.
Accordingly, the prior art does not provide an adequate means for analyzing complex host computer and embedded microprocessor based software systems and for cutting through the ambiguities of microprocessor prefetch and cache operations. Moreover, no prior art system is adequately designed to benefit large software design teams developing large and complex embedded applications making use of a multitasking operating system and/or object oriented systems with real-time requirements. The present invention has been designed to meet these needs.